Instance 0

Class110.sendRecvData(String testDescription,boolean eofExpected)#8{
      sock = new Socket();
      sock.connect(dnAddr, HdfsServerConstants.READ_TIMEOUT);
      sock.setSoTimeout(HdfsServerConstants.READ_TIMEOUT);
      OutputStream out = sock.getOutputStream();
}


Instance 1

Class270.getPartial(String url)#1{
            Socket s = new Socket();
            s.connect(addr);
            s.setSoTimeout(100);
            OutputStream os = s.getOutputStream();
}


Instance 2

Class340.sendRecvData(String testDescription,boolean eofExpected)#0{
      sock = new Socket();
      sock.connect(dnAddr, HdfsConstants.READ_TIMEOUT);
      sock.setSoTimeout(HdfsConstants.READ_TIMEOUT);
      OutputStream out = sock.getOutputStream();
}


Instance 3

Class610.test_connectLjava_net_SocketAddress()#8{
        Socket theSocket = new Socket();
            theSocket.connect(null);
        theSocket = new Socket();
}


Instance 4

Class500.queryServerPing(InetSocketAddress address)#3{
            socket = new Socket();
            socket.connect(address, CONNECT_TIMEOUT);
            socket.setSoTimeout(READ_TIMEOUT);
            output = socket.getOutputStream();
            input = socket.getInputStream();
            DataOutputStream data = new DataOutputStream(output);
}


Instance 5

Class160.send4LetterWord(String host,int port,String cmd,boolean secure,int timeout)#6{
            sock = new Socket();
            sock.connect(hostaddress, timeout);
        sock.setSoTimeout(timeout);
            OutputStream outstream = sock.getOutputStream();
}


Instance 6

Class140.getStream(String request)#0{
    Socket s = socketPool.poll();
    if (s == null || s.isClosed() || s.isOutputShutdown() || s.isInputShutdown())
    {
      s = new Socket();
      s.connect( address );
    }
    DataOutputStream o = new DataOutputStream( s.getOutputStream() );
    o.writeInt( path.length );
    o.write( path );
    o.flush();
}


Instance 7

Class60.bestNode(T[] nodes,boolean doRandom)#3{
        s = new Socket();
        s.connect(targetAddr, HdfsConstants.READ_TIMEOUT);
        s.setSoTimeout(HdfsConstants.READ_TIMEOUT);
}


Instance 8

Class50.streamBlockInAscii(InetSocketAddress addr,String poolId,long blockId,Token<BlockTokenIdentifier> blockToken,long genStamp,long blockSize,long offsetIntoBlock,long chunkSizeToView,JspWriter out,Configuration conf)#0{
    Socket s = new Socket();
    s.connect(addr, HdfsServerConstants.READ_TIMEOUT);
    s.setSoTimeout(HdfsServerConstants.READ_TIMEOUT);
}


Instance 9

Class330.tryRead(Configuration conf,LocatedBlock lblock,boolean shouldSucceed)#0{
      s = new Socket();
      s.connect(targetAddr, HdfsServerConstants.READ_TIMEOUT);
      s.setSoTimeout(HdfsServerConstants.READ_TIMEOUT);
}


Instance 10

Class330.bestNode(DatanodeInfo[] nodes,boolean doRandom)#2{
        s = new Socket();
        s.connect(targetAddr, HdfsServerConstants.READ_TIMEOUT);
        s.setSoTimeout(HdfsServerConstants.READ_TIMEOUT);
}


Instance 11

Class650.copyBlock(DFSClient dfs,LocatedBlock lblock,OutputStream fos)#2{
        s = new Socket();
        s.connect(targetAddr, HdfsServerConstants.READ_TIMEOUT);
        s.setSoTimeout(HdfsServerConstants.READ_TIMEOUT);
}


Instance 12

Class610.streamBlockInAscii(InetSocketAddress addr,int namespaceId,long blockId,long genStamp,long blockSize,long offsetIntoBlock,long chunkSizeToView,JspWriter out)#0{
    Socket s = new Socket();
    s.connect(addr, HdfsConstants.READ_TIMEOUT);
    s.setSoTimeout(HdfsConstants.READ_TIMEOUT);
}


Instance 13

Class410.getBlockReader(int offset,int lenToRead)#2{
    s = new Socket();
    s.connect(targetAddr, HdfsConstants.READ_TIMEOUT);
    s.setSoTimeout(HdfsConstants.READ_TIMEOUT);
}


Instance 14

Class150.accessBlock(DatanodeInfo datanode,LocatedBlock lblock)#2{
    s = new Socket();
    s.connect(targetAddr, HdfsServerConstants.READ_TIMEOUT);
    s.setSoTimeout(HdfsServerConstants.READ_TIMEOUT);
}


Instance 15

Class0.getBlockReader(LocatedBlock testBlock,int offset,int lenToRead)#3{
    sock = new Socket();
    sock.connect(targetAddr, HdfsConstants.READ_TIMEOUT);
    sock.setSoTimeout(HdfsConstants.READ_TIMEOUT);
}


Instance 16

Class390.borrowSocket()#1{
    Socket socket = socketBlockingQueue.poll();
    if (socket != null) {
      if (socket.isClosed() || !socket.isConnected() ||
        socket.isInputShutdown() || socket.isOutputShutdown()) {

        try {
          socket.close();
        }
        catch (IOException ioe) {
          if (_log.isWarnEnabled()) {
            _log.warn(ioe, ioe);
          }
        }

        socket = null;
      }
    }
    if (socket == null) {
      socket = new Socket();

      socket.connect(socketAddress);
    }
}


Instance 17

Class220.slowWebSocketClient(String url)#1{
            Socket s = new Socket();
            s.connect(addr);
            OutputStream os = s.getOutputStream();
            InputStream is = s.getInputStream();
}


Instance 18

Class250.test_connectLjava_net_SocketAddressI()#4{
        Socket client = new Socket();
        client.connect(boundAddress, 0);
        assertTrue("Wrong connected status", client.isConnected());
        assertFalse("Wrong closed status", client.isClosed());
        assertTrue("Wrong bound status", client.isBound());
        assertFalse("Wrong input shutdown status", client.isInputShutdown());
        assertFalse("Wrong output shutdown status", client.isOutputShutdown());
        assertTrue("Local port was 0", client.getLocalPort() != 0);
        client.close();
}


Instance 19

Class610.test_connectLjava_net_SocketAddress()#2{
        Socket client = new Socket();
        client.connect(boundAddress);
        assertTrue("Wrong connected status", client.isConnected());
        assertFalse("Wrong closed status", client.isClosed());
        assertTrue("Wrong bound status", client.isBound());
        assertFalse("Wrong input shutdown status", client.isInputShutdown());
        assertFalse("Wrong output shutdown status", client.isOutputShutdown());
        assertTrue("Local port was 0", client.getLocalPort() != 0);
        client.close();
}


Instance 20

Class410.operate(int cmd,Interp interp,Thing[] argv)#3{
        Socket sock = new Socket();
        sock.connect(isa);
        HeclChannel retval = new HeclChannel(new DataInputStream(sock.getInputStream()),
               new DataOutputStream(sock.getOutputStream()));
        return ObjectThing.create(retval);
}


Instance 21

Class360.pingServer(){
            final Socket socket = new Socket();
            socket.connect(address, 1500);
            socket.close();
}


Instance 22

Class360.runObscuredTest(String pattern,String testAddress,boolean shouldObscure)#0{
        Socket socket = new Socket();
            socket.connect(connectAddress, 125);
            socket.close(); // just in case it somehow succeeded
}


Instance 23

Class560.runAcceptorTest(String testName,SocketAcceptorHelper<?> acceptor)#2{
            Socket socket = new Socket();
            socket.connect(connectAddress, 125);
            socket.close(); // just in case it somehow succeeded
}


Instance 24

Class290.waitForServer(String urlString)#0{
                Socket test = new Socket();
                test.connect(sa, WAIT_TIME);
                   test.close();
}


Instance 25

Class300.checkhost(String host)#0{
    Socket test = new Socket();
    test.connect(sockaddr, timeoutMs);
    test.close();
}


Instance 26

Class310.checkVitality(String host,int port,int timeout)#3{
                Socket socket = new Socket();
                socket.connect(socketAddress, timeout);
                socket.close();
}


Instance 27

Class240.http10(String url)#0{
        Socket s = new Socket();
        s.connect(addr);
        OutputStream os = s.getOutputStream();
}


Instance 28

Class20.testBadRequest()#0{
    Socket sock = new Socket();
    sock.connect(sockAddr);
    OutputStream out = sock.getOutputStream();
}


Instance 29

Class530.run()#10{
                    Socket s = new Socket();
                    s.connect(relayServerEndpoint);
                    MessageWriter dataConnectionWriter = new MessageWriter(s.getOutputStream());
}


Instance 30

Class70.AddressTest()#18{
        soc.close();
        soc = new Socket();
            soc.connect(addr, 100);
}


Instance 31

Class130.connectViaCliPort(URL jenkins,CliPort clip)#10{
            out = new SocketOutputStream(s) {
                @Override
                public void close() throws IOException {
                    // ignore
                }
            };
            s = new Socket();
            s.connect(clip.endpoint,3000);
            out = SocketChannelStream.out(s);
                s.close();
}


Instance 32

Class610.test_setReuseAddressZ()#6{
        theSocket = new Socket();
        theSocket.connect(theAddress);
        stillActiveSocket = serverSocket.accept();
        serverSocket.close();
            serverSocket = new ServerSocket();
            serverSocket.bind(theAddress);
            fail("Unexpected exception when setReuseAddress is the default case and we bind:"
                    + theAddress.toString() + ":" + ex.toString());
}


Instance 33

Class610.test_setReuseAddressZ()#13{
        Socket theSocket = new Socket();
        theSocket.connect(theAddress);
        Socket stillActiveSocket = serverSocket.accept();
        serverSocket.close();
}


Instance 34

Class610.test_setReuseAddressZ()#1{
        theSocket = new Socket();
        theSocket.connect(theAddress);
        stillActiveSocket = serverSocket.accept();
        serverSocket.close();
            serverSocket = new ServerSocket();
            serverSocket.setReuseAddress(true);
            serverSocket.bind(theAddress);
            fail("Unexpected exception when setReuseAddress is true and we bind:"
                    + theAddress.toString() + ":" + ex.toString());
}


Instance 35

Class280.test_bindLjava_net_SocketAddressI()#7{
        Socket clientSocket = new Socket();
        clientSocket.connect(localAddress);
        Socket servSock = theSocket.accept();
}


Instance 36

Class670.InheritTimeout()#0{
        Socket s1 = new Socket();
        s1.connect(isa);
        Socket s2 = ss.accept();
        Reaper r = new Reaper(s2, 5000);
        r.start();
}


Instance 37

Class290.canConnect(Member member)#1{
                    if (log.isDebugEnabled()) {
                        log.debug("HTTP Port=" + httpPort);
                    }
                    if (httpPort != -1) {
                        SocketAddress httpSockaddr = new InetSocketAddress(addr, httpPort);
                        new Socket().connect(httpSockaddr, 10000);
                    }
                    int httpsPort = member.getHttpsPort();
}


Instance 38

Class640.check(String host)#3{
      clientSocket = new Socket();
      clientSocket.connect(endpoint, 2000);
      in = clientSocket.getInputStream();
}


Instance 39

Class190.connect(ImapSettings settings,TrustedSocketFactory socketFactory)#0{
                    Log.d(LOG_TAG, "Connecting to " + settings.getHost() + " as " + address);
                SocketAddress socketAddress = new InetSocketAddress(address, settings.getPort());
                if (settings.getConnectionSecurity() == ConnectionSecurity.SSL_TLS_REQUIRED) {
                    socket = socketFactory.createSocket(
                            null,
                            settings.getHost(),
                            settings.getPort(),
                            settings.getClientCertificateAlias());
                } else {
                    socket = new Socket();
                }
                socket.connect(socketAddress, SOCKET_CONNECT_TIMEOUT);
                Log.w(LOG_TAG, "could not connect to "+address, e);
        throw new MessagingException("Cannot connect to host", connectException);
}


Instance 40

Class210.loadCachesFromCluster(String portalCacheManagerName,String... portalCacheNames)#5{
      socket = new Socket();
      socket.connect(remoteSocketAddress);
      socket.shutdownOutput();
        new AnnotatedObjectInputStream(socket.getInputStream());
}


Instance 41

Class480.testCreateLayeredSocket()#1{
      @Cleanup Socket plain = new Socket();
      plain.connect(sampleTlsEndpoint);
      assertTrue(plain.isConnected());
}


Instance 42

Class370.connect(String host,int port,int connectTimeOut)#2{
    socket = new Socket();
    socket.connect( sockAddr, connectTimeOut );
}


Instance 43

Class570.run(){
      (new Socket()).connect(new InetSocketAddress("localhost", 1));
}


Instance 44

Class450.openSocket(){
    (new Socket()).connect(new InetSocketAddress("localhost", 1));
}


Instance 45

Class250.test_connectLjava_net_SocketAddressI()#11{
        Socket theSocket = new Socket();
            theSocket.connect(null, 0);
}


Instance 46

Class280.onlineZooKeeperServers()#19{
          Socket testServerSock = new Socket();
          testServerSock.connect(zkServerAddress, 5000);
}


Instance 47

Class50.main(String[] args)#4{
        Socket s = new Socket();
            s.connect(ad,10000);
}


Instance 48

Class490.canConnect(org.apache.axis2.clustering.Member member)#2{
                new Socket().connect(sockaddr, 500);
}


Instance 49

Class300.testRedis(InetSocketAddress socketAddress)#4{
    Socket socket = new Socket();
    socket.connect(socketAddress);
}


Instance 50

Class630.isPortOpen(InetSocketAddress socketAddress)#2{
    Socket socket = new Socket();
      socket.connect(socketAddress, timeout);
}


Instance 51

Class580.sendCommand(final String command)#0{
                socket = new Socket();
                socket.connect(this.socketAddress);
                writeLine0(socket, this.secretKey + " " + command);
                final String result = readLine(socket);
                Main.info("Sent '" + command + "' to " + this.socketAddress + ": " + result, null);
                Main.info("No Apache Sling running at " + this.socketAddress, null);
                Main.error("Failed sending '" + command + "' to " + this.socketAddress, ioe);
}


Instance 52

Class220.NonRespondingSocketService(int port)#1{
        new Socket().connect(serverSocket.getLocalSocketAddress());
}


Instance 53

Class430.createDestination(String destination)#0{
      Socket sock = new Socket();
      sock.connect(addr);
      TTransport transport = new TSocket(sock);
      TProtocol prot = new TBinaryProtocol(transport);
      return new Client(prot);
}


Instance 54

Class190.checkPortsActive(String ipAddress,List<Integer> ports)#5{
                socket = new Socket();
                socket.connect(httpSockaddr, 5000);
}


Instance 55

Class90.Test(SocketAddress sa)#8{
        Socket s = new Socket();
        s.connect(sa);
}


Instance 56

Class460.disable_testConnectWithIP4IPAddr()#2{
        Socket clntSckt = new Socket();
            clntSckt.connect(scktAddrss, 5000);
}


Instance 57

Class690.tryConnect(AvatarNode node)#1{
      Socket s = new Socket();
      s.connect(addr);
}


Instance 58

Class600.getNewSocket()#4{
      socket = new Socket();
      socket.connect(sockaddr);
}


Instance 59

Class180.checkPort(String name,InetSocketAddress address,int connectTimeout)#0{
      socket = new Socket();
      socket.connect(address, connectTimeout);
      throw new IOException("Failed to connect to " + name
                            + " at " + address
                            + " after " + connectTimeout + "millisconds"
                            + ": " + e,
          e);
}


Instance 60

Class360.testZookeeper(InetSocketAddress socketAddress)#0{
    Socket socket = new Socket();
    socket.connect(socketAddress);
}


Instance 61

Class520.createSocket(final String host,final int port)#1{
        final Socket newSocket = new Socket();
        newSocket.connect(address, connectTimeoutMillis);
}


Instance 62

Class410.connectionTest(String address,int port)#2{
      socket = new Socket();
            socket.connect(sockaddr, 2000);
}


Instance 63

Class410.testSocketExternalResourceAnalyzer()#0{
        final Socket socket = new Socket();
            socket.connect(connectAddress, 125);
            Assert.fail("Unexpected success to connect to " + connectAddress);
}


Instance 64

Class10.testStopListenting()#4{
            Socket socket = new Socket();
                socket.connect(serverAddress);
}


Instance 65

Class170.create(final SocketAddress pSocketAddress,final int pTimeoutMilliseconds){
    final Socket socket = new Socket();
    socket.connect(pSocketAddress, pTimeoutMilliseconds);
    return new SocketConnection(socket);
}


Instance 66

Class290.canConnect(Member member)#0{
                        new Socket().connect(httpsSockaddr, 10000);
}


Instance 67

Class290.testMemcache(InetSocketAddress socketAddress)#2{
    Socket socket = new Socket();
    socket.connect(socketAddress);
}


Instance 68

Class510.shouldStartAndStopMongoD()#0{
    MongoProcessHolder mongoProcess = LocalMongoFactory.createMongoProcess();
    mongoProcess.stopMongo();
      new Socket().connect(new InetSocketAddress(mongoProcess.getMongoPort()), 1);
}


Instance 69

Class510.connect(int port,IProgress waitReporter)#0{
        s = new Socket();
        s.connect(localAddress, totalTimeout);
}


Instance 70

Class270.sendCommand(String command)#0{
                socket = new Socket();
                socket.connect(socketAddress);
                writeLine(socket, command);
                String result = readLine(socket);
                log.info("Sent '" + command + "' to " + socketAddress + ": " + result, null);
                log.info("No Sling running at " + socketAddress, null);
                log.error("Failed sending '" + command + "' to " + socketAddress, ioe);
}